FP Workshop - 1. Functional vs Imperative

const products = [
  { id: 'candy', name: 'Candy', price: 10, onSale: true },
  { id: 'ice-cream', name: 'Ice cream', price: 20, onSale: true },
  { id: 'cake', name: 'Cake', price: 30, onSale: false },
  { id: 'donuts', name: 'Donuts', price: 12, onSale: true },
  { id: 'chocolate', name: 'Chocolate', price: 15, onSale: false },
  { id: 'flower', name: 'Flower', price: 40, onSale: false },
  { id: 'sofa', name: 'Sofa', price: 120, onSale: true },
  { id: 'bed', name: 'Bed', price: 400, onSale: true },
];

// Imperative
function imperative() {
  let total = 0;
  let count = 0;
  for (const a of products) {
    if (a.price < 30) {
      total += a.price;
      count++;
    }
    if (count === 3) break;
  }
  console.log(total);
}

const isIterable = (iter) => typeof iter[Symbol.iterator] === 'function';
const curry =
  (f) =>
  (a, ...args) =>
    args.length ? f(a, ...args) : (...args2) => f(a, ...args2);

const map = curry(function* (f, iter) {
  for (const a of iter) {
    yield f(a);
  }
});

const filter = curry(function* (f, iter) {
  for (const a of iter) {
    if (f(a)) yield a;
  }
});

const take = curry((length, iter) => {
  const res = [];
  for (const a of iter) {
    res.push(a);
    if (res.length === length) return res;
  }
});

const reduce = curry((f, acc, iter) => {
  if (!iter && isIterable(acc)) {
    iter = acc[Symbol.iterator]();
    acc = iter.next().value;
  }

  for (const a of iter) {
    acc = f(acc, a);
  }

  return acc;
});

const add = curry((a, b) => a + b);

const pipe = (...args) => reduce((a, f) => f(a), args);

// Functional
pipe(
  products,
  map((a) => a.price),
  filter((p) => p < 30),
  take(3),
  reduce(add),
  console.log,
);

pipe(
  products,
  map((a) => a.price), // Lazy
  filter((p) => p < 30), // Lazy
  take(3),
  reduce(add),
  console.log,
);